const dayjs = require('dayjs');
/**
 * passport_biz_config.js
 * 用户通行证业务逻辑统一入口点
 */

// 直接内联passport_biz.js的内容
/**
 * Notes: 注册登录模块业务逻辑
 * Ver : CCMiniCloud Framework 2.0.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2020-11-14 07:48:00 
 */

const BaseBiz = require('./base_biz_config.js');
const cacheHelper = require('../helpers/cache_helper.js');
const cloudHelper = require('../helpers/cloud_helper.js');
const pageHelper = require('../helpers/page_helper.js');
const helper = require('../helpers/helper.js');
const constants = require('../constants/constants.js');

class PassportBiz extends BaseBiz {

	// 静默登录(有登录状态则不登录)  
	static async loginSilence(that = null, backUrl = '', successCallback = null) {
		// 检查是否有永久登出标记
		let manualLogout = wx.getStorageSync('MANUAL_LOGOUT');
		if (manualLogout) {
			console.log('loginSilence: 检测到永久登出标记，跳过自动登录');
			if (that) {
				that.setData({
					isLogin: false
				});
			}
			return false;
		}
		
		// 检查是否刚刚执行过登出操作
		let logoutTime = wx.getStorageSync('LOGOUT_TIME');
		let now = dayjs().valueOf();
		
		// 如果在过去30秒内执行过登出，直接返回未登录状态
		if (logoutTime && (now - logoutTime < 30 * 1000)) {
			console.log('loginSilence: 检测到最近的登出操作，跳过自动登录');
			if (that) {
				that.setData({
					isLogin: false
				});
			}
			return false;
		}
		
		// 判断是否有token
		if (!PassportBiz.isLogin()) {
			// 本地token无效或过期，尝试重新登录
			return await PassportBiz.loginCheck(false, 'slience', 'bar', that);
		}
		
		// 使用API二次验证
		let user = await PassportBiz.getMyDetailWithCache();
		if (user) {
			if (that) {
				that.setData({
					isLogin: true
				});
			}
			return true;
		}
		
		return false;
	}

	// 强制静默登录(有不论是否有登录状态)  
	static async loginSilenceMust(that) {
		// 检查是否有永久登出标记
		let manualLogout = wx.getStorageSync('MANUAL_LOGOUT');
		if (manualLogout) {
			console.log('loginSilenceMust: 检测到永久登出标记，跳过强制登录');
			if (that) {
				that.setData({
					isLogin: false
				});
			}
			return false;
		}
		
		// 检查是否刚刚执行过登出操作
		let logoutTime = wx.getStorageSync('LOGOUT_TIME');
		let now = dayjs().valueOf();
		
		// 如果在过去30秒内执行过登出，则不执行强制登录
		if (logoutTime && (now - logoutTime < 30 * 1000)) {
			console.log('loginSilenceMust: 检测到最近的登出操作，跳过强制登录');
			if (that) {
				that.setData({
					isLogin: false
				});
			}
			return false;
		}
		
		return await PassportBiz.loginCheck(false, 'must', 'bar', that);
	}

	// 必须登陆 可以取消(窗口形式) 
	static async loginMustCancelWin(that) {
		return await PassportBiz.loginCheck(true, 'cancel', '', that);
	}

	// 必须登陆 只能强制注册或者回上页(窗口形式)  
	static async loginMustBackWin(that) {
		return await PassportBiz.loginCheck(true, 'back', '', that);
	}

	// 获取token  
	static getToken() {
		let token = cacheHelper.get(constants.CACHE_TOKEN);
		console.log('获取token:', token);
		return token || null;
	}

	// 设置token
	static setToken(token) {
		if (!token) return;
		console.log('设置token:', token);
		
		// 同步到所有可能的缓存位置
		cacheHelper.set(constants.CACHE_TOKEN, token, constants.CACHE_TOKEN_EXPIRE);
		cacheHelper.set('CCMINI_TOKEN', token, constants.CACHE_TOKEN_EXPIRE);
		
		// 同时保存到本地存储
		wx.setStorageSync(constants.CACHE_TOKEN, token);
		wx.setStorageSync('CCMINI_TOKEN', token);
		
		// 设置刷新时间
		wx.setStorageSync('TOKEN_REFRESH_TIME', dayjs().valueOf());
	}

	//  获取user id 
	static getUserId() {
		let token = cacheHelper.get(constants.CACHE_TOKEN);
		if (!token) return '';
		return token.id || '';
	}

	// 获取user name 
	static getUserName() {
		let token = cacheHelper.get(constants.CACHE_TOKEN);
		if (!token) return '';
		return token.name || '';
	}

	static getStatus() {
		let token = cacheHelper.get(constants.CACHE_TOKEN);
		if (!token) return -1;
		return token.status || -1;
	}

	// 登录状态接口
	static isLogin() {
		// 检查是否有永久登出标记
		let manualLogout = wx.getStorageSync('MANUAL_LOGOUT');
		if (manualLogout) {
			console.log('isLogin: 检测到永久登出标记，视为未登录状态');
			return false;
		}

		// 检查所有可能的token位置
		let token = null;
		
		// 1. 优先从系统缓存获取
		token = cacheHelper.get(constants.CACHE_TOKEN);
		
		// 2. 如果没有，尝试从CCMINI_TOKEN获取
		if (!token || !token.id || !token.name) {
			token = cacheHelper.get('CCMINI_TOKEN');
			// 如果找到了有效Token，同步到主缓存位置
			if (token && token.id && token.name) {
				cacheHelper.set(constants.CACHE_TOKEN, token, constants.CACHE_TOKEN_EXPIRE);
			}
		}
		
		// 3. 尝试从本地存储获取
		if (!token || !token.id || !token.name) {
			token = wx.getStorageSync(constants.CACHE_TOKEN);
			// 如果找到了有效Token，同步到所有缓存位置
			if (token && token.id && token.name) {
				cacheHelper.set(constants.CACHE_TOKEN, token, constants.CACHE_TOKEN_EXPIRE);
				cacheHelper.set('CCMINI_TOKEN', token, constants.CACHE_TOKEN_EXPIRE);
			}
		}
		
		// 4. 最后尝试从CCMINI_TOKEN本地存储获取
		if (!token || !token.id || !token.name) {
			token = wx.getStorageSync('CCMINI_TOKEN');
			// 如果找到了有效Token，同步到所有缓存位置
			if (token && token.id && token.name) {
				cacheHelper.set(constants.CACHE_TOKEN, token, constants.CACHE_TOKEN_EXPIRE);
				cacheHelper.set('CCMINI_TOKEN', token, constants.CACHE_TOKEN_EXPIRE);
				wx.setStorageSync(constants.CACHE_TOKEN, token);
			}
		}
		
		// 检查格式 - 不立即清除，而是返回false让调用者有机会修复
		if (!token || !token.id || !token.name) {
			console.log('检测到无效的TOKEN(缺少用户ID或名称)，但不立即清除');
			return false;
		}
		
		return true;
	}

	static isAdmin() {
		let token = cacheHelper.get(constants.CACHE_TOKEN);
		let admin = cacheHelper.get(constants.CACHE_ADMIN);
		if (admin) return true;
		if (!token) return false;
		return (token && token.type && token.type == 1) ? true : false;
	}
	
	// 清除token
	static clearToken() {
		console.log('清除token');
		cacheHelper.remove(constants.CACHE_TOKEN);
		cacheHelper.remove('CCMINI_TOKEN');
		wx.removeStorageSync(constants.CACHE_TOKEN);
		wx.removeStorageSync('CCMINI_TOKEN');
		
		// 记录登出时间
		wx.setStorageSync('LOGOUT_TIME', dayjs().valueOf());
	}
	
	// 手动登出 - 用户主动操作，在缓存中标记
	static manualLogout() {
		console.log('手动登出');
		PassportBiz.clearToken();
		
		// 设置永久登出标记（直到用户主动登录为止）
		wx.setStorageSync('MANUAL_LOGOUT', true);
	}
	
	// 获取我的信息 优先从缓存
	static async getMyDetailWithCache() {
		// 先从缓存获取
		let user = cacheHelper.get(constants.CACHE_USER);
		if (user) return user;

		// 如果没有缓存，从API获取
		try {
			user = await PassportBiz.getMyDetail();
			if (user) {
				console.log('更新用户缓存');
				cacheHelper.set(constants.CACHE_USER, user);
			}
			return user;
		} catch (e) {
			console.error('获取用户信息失败', e);
			return null;
		}
	}
	
	// 获取我的信息
	static async getMyDetail() {
		try {
			const result = await cloudHelper.callCloudData('user/my_detail');
			if (result) {
				return result;
			} else {
				// 清除缓存
				cacheHelper.remove(constants.CACHE_USER);
				return null;
			}
		} catch (e) {
			// API错误，清除缓存
			cacheHelper.remove(constants.CACHE_USER);
			return null;
		}
	}
	
	// 使用API检查登录状态
	static async checkLoginWithApi(that = null) {
		try {
			await PassportBiz.getMyDetail();
			if (that) {
				that.setData({
					isLogin: true
				});
			}
			return true;
		} catch (e) {
			if (that) {
				that.setData({
					isLogin: false
				});
			}
			return false;
		}
	}

	// 登录判断及处理
	static async loginCheck(mustLogin = false, method = 'back', title = '', that = null) {
		// 检查是否有永久登出标记
		let manualLogout = wx.getStorageSync('MANUAL_LOGOUT');
		
		// 检查是否刚刚执行过登出操作
		let logoutTime = wx.getStorageSync('LOGOUT_TIME');
		let now = dayjs().valueOf();
		
		// 无论method是什么，如果在过去30秒内执行过登出或有永久登出标记，都忽略登录检查
		if ((logoutTime && (now - logoutTime < 30 * 1000)) || manualLogout) {
			console.log('loginCheck: 检测到登出状态，忽略登录检查');
			if (that) {
				that.setData({
					isLogin: false
				});
			}
			return false;
		}
		
		let token = cacheHelper.get(constants.CACHE_TOKEN);
		if (token && method != 'must') {
			// 检查token完整性
			if (!token.id || !token.name) {
				// Token不完整，尝试从存储中恢复
				console.log('loginCheck: 检测到不完整的Token，尝试恢复');
				let userInfo = cacheHelper.get('USER_INFO') || wx.getStorageSync('USER_INFO');
				if (userInfo && userInfo.id) {
					// 创建新token
					let newToken = {
						id: userInfo.id,
						name: userInfo.name || '用户',
						status: 1,
						type: 1,
						dept: userInfo.dept || ''
					};
					cacheHelper.set(constants.CACHE_TOKEN, newToken, constants.CACHE_TOKEN_EXPIRE || 86400 * 1000);
					console.log('loginCheck: 已从用户信息恢复Token');
					token = newToken;
				}
			}
			
			// 再次检查token
			if (token && token.id && token.name) {
				if (that) {
					that.setData({
						isLogin: true
					});
				}
				return true;
			}
		}
		
		if (that) {
			that.setData({
				isLogin: false
			});
		}

		// 如果是强制登出状态，不执行自动登录
		if (manualLogout) {
			console.log('loginCheck: 检测到强制登出状态，跳过自动登录');
			return false;
		}

		// 如果mustLogin为true但没有找到有效的登录信息，引导用户去登录页面
		if (mustLogin) {
			console.log('loginCheck: 需要登录，引导用户到登录页面');
			if (method == 'cancel') {
				wx.showModal({
					title: '温馨提示',
					content: '此功能仅限注册用户',
					confirmText: '马上登录',
					cancelText: '取消',
					success(result) {
						if (result.confirm) {
							let url = pageHelper.fmtURLByPID('/pages/my_user/login/my_login') + '?retUrl=back';
							wx.navigateTo({ url });
						}
					}
				});
			} else if (method == 'back') {
				wx.showModal({
					title: '温馨提示',
					content: '此功能仅限注册用户',
					confirmText: '马上登录',
					cancelText: '返回',
					success(result) {
						if (result.confirm) {
							let retUrl = encodeURIComponent(pageHelper.getCurrentPageUrlWithArgs());
							let url = pageHelper.fmtURLByPID('/pages/my_user/login/my_login') + '?retUrl=' + retUrl;
							wx.redirectTo({ url });
						} else if (result.cancel) {
							let len = getCurrentPages().length;
							if (len == 1) {
								let url = pageHelper.fmtURLByPID('/pages/default/index/default_index');
								wx.reLaunch({ url });
							}
							else
								wx.navigateBack();
						}
					}
				});
			}
			return false;
		}

		// 非强制登录模式下，直接返回未登录状态，不尝试自动登录
		console.log('loginCheck: 非强制登录模式，静默返回未登录状态');
		return false;
	}

	static loginStatusHandler(method, status) {
		let content = '';
		if (status == 0) content = '您的注册正在审核中，暂时无法使用此功能！';
		else if (status == 8) content = '您的注册审核未通过，暂时无法使用此功能；请在个人中心修改资料，再次提交审核！';
		else if (status == 9) content = '您的账号已经禁用, 无法使用此功能！';
		if (method == 'cancel') {
			wx.showModal({
				title: '温馨提示',
				content,
				confirmText: '取消',
				showCancel: false
			});
		}
		else if (method == 'back') {
			wx.showModal({
				title: '温馨提示',
				content,
				confirmText: '返回',
				showCancel: false,
				success(result) {
					wx.navigateBack();
				}
			});
		}
		return false;
	}
}

module.exports = PassportBiz;